#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <memory>
#include <vector>
#include <string>
#include <thread>
#include <chrono>
#include <atomic>
#include <functional>

/**
 * 事件通知器综合测试类
 * 测试事件通知机制的各种场景和边界条件
 */
class EventNotifierComprehensiveTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 测试环境初始化
        event_count_ = 0;
        error_count_ = 0;
    }

    void TearDown() override {
        // 测试环境清理
    }

    std::atomic<int> event_count_;
    std::atomic<int> error_count_;
};

/**
 * 简单的事件通知器实现用于测试
 */
class SimpleEventNotifier {
public:
    using EventHandler = std::function<void(const std::string&, const std::string&)>;
    
    SimpleEventNotifier() : running_(false) {}
    
    ~SimpleEventNotifier() {
        stop();
    }
    
    // 启动事件通知器
    void start() {
        running_ = true;
    }
    
    // 停止事件通知器
    void stop() {
        running_ = false;
        // 清理所有处理器
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        handlers_.clear();
    }
    
    // 注册事件处理器
    void register_handler(const std::string& event_type, EventHandler handler) {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        handlers_[event_type].push_back(handler);
    }
    
    // 注销事件处理器
    void unregister_handlers(const std::string& event_type) {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        handlers_.erase(event_type);
    }
    
    // 触发事件
    void notify_event(const std::string& event_type, const std::string& event_data) {
        if (!running_) {
            return;
        }
        
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        auto it = handlers_.find(event_type);
        if (it != handlers_.end()) {
            for (auto& handler : it->second) {
                try {
                    handler(event_type, event_data);
                } catch (...) {
                    // 处理器异常不应该影响其他处理器
                }
            }
        }
    }
    
    // 异步触发事件
    void notify_event_async(const std::string& event_type, const std::string& event_data) {
        if (!running_) {
            return;
        }
        
        std::thread([this, event_type, event_data]() {
            notify_event(event_type, event_data);
        }).detach();
    }
    
    // 获取注册的事件类型数量
    size_t get_event_types_count() const {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        return handlers_.size();
    }
    
    // 获取指定事件类型的处理器数量
    size_t get_handlers_count(const std::string& event_type) const {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        auto it = handlers_.find(event_type);
        return (it != handlers_.end()) ? it->second.size() : 0;
    }
    
    // 检查是否正在运行
    bool is_running() const {
        return running_;
    }

private:
    std::atomic<bool> running_;
    mutable std::mutex handlers_mutex_;
    std::map<std::string, std::vector<EventHandler>> handlers_;
};

/**
 * 测试基本事件通知功能
 */
TEST_F(EventNotifierComprehensiveTest, TestBasicEventNotification) {
    SimpleEventNotifier notifier;
    
    // 注册事件处理器
    notifier.register_handler("test_event", [&](const std::string& type, const std::string& data) {
        EXPECT_EQ(type, "test_event");
        EXPECT_EQ(data, "test_data");
        event_count_.fetch_add(1);
    });
    
    // 启动通知器
    notifier.start();
    EXPECT_TRUE(notifier.is_running());
    
    // 触发事件
    notifier.notify_event("test_event", "test_data");
    
    // 验证事件被处理
    EXPECT_EQ(event_count_.load(), 1);
    EXPECT_EQ(notifier.get_event_types_count(), 1);
    EXPECT_EQ(notifier.get_handlers_count("test_event"), 1);
    
    // 停止通知器
    notifier.stop();
    EXPECT_FALSE(notifier.is_running());
}

/**
 * 测试多个事件处理器
 */
TEST_F(EventNotifierComprehensiveTest, TestMultipleEventHandlers) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    // 注册多个处理器
    for (int i = 0; i < 5; ++i) {
        notifier.register_handler("multi_event", [&, i](const std::string& type, const std::string& data) {
            EXPECT_EQ(type, "multi_event");
            event_count_.fetch_add(1);
        });
    }
    
    EXPECT_EQ(notifier.get_handlers_count("multi_event"), 5);
    
    // 触发事件
    notifier.notify_event("multi_event", "test_data");
    
    // 验证所有处理器都被调用
    EXPECT_EQ(event_count_.load(), 5);
}

/**
 * 测试多种事件类型
 */
TEST_F(EventNotifierComprehensiveTest, TestMultipleEventTypes) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    std::vector<std::string> event_types = {
        "order_event", "trade_event", "market_event", "system_event", "error_event"
    };
    
    // 为每种事件类型注册处理器
    for (const auto& event_type : event_types) {
        notifier.register_handler(event_type, [&](const std::string& type, const std::string& data) {
            event_count_.fetch_add(1);
        });
    }
    
    EXPECT_EQ(notifier.get_event_types_count(), event_types.size());
    
    // 触发所有事件类型
    for (const auto& event_type : event_types) {
        notifier.notify_event(event_type, "test_data");
    }
    
    // 验证所有事件都被处理
    EXPECT_EQ(event_count_.load(), event_types.size());
}

/**
 * 测试异步事件通知
 */
TEST_F(EventNotifierComprehensiveTest, TestAsyncEventNotification) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    const int NUM_ASYNC_EVENTS = 100;
    
    // 注册异步事件处理器
    notifier.register_handler("async_event", [&](const std::string& type, const std::string& data) {
        // 模拟处理时间
        std::this_thread::sleep_for(std::chrono::microseconds(10));
        event_count_.fetch_add(1);
    });
    
    // 异步触发多个事件
    for (int i = 0; i < NUM_ASYNC_EVENTS; ++i) {
        notifier.notify_event_async("async_event", "async_data_" + std::to_string(i));
    }
    
    // 等待所有异步事件处理完成
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    
    // 验证所有异步事件都被处理
    EXPECT_EQ(event_count_.load(), NUM_ASYNC_EVENTS);
}

/**
 * 测试事件处理器异常处理
 */
TEST_F(EventNotifierComprehensiveTest, TestEventHandlerExceptions) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    // 注册会抛出异常的处理器
    notifier.register_handler("exception_event", [&](const std::string& type, const std::string& data) {
        error_count_.fetch_add(1);
        throw std::runtime_error("Handler exception");
    });
    
    // 注册正常的处理器
    notifier.register_handler("exception_event", [&](const std::string& type, const std::string& data) {
        event_count_.fetch_add(1);
    });
    
    // 触发事件
    notifier.notify_event("exception_event", "test_data");
    
    // 验证异常不会阻止其他处理器执行
    EXPECT_EQ(error_count_.load(), 1);
    EXPECT_EQ(event_count_.load(), 1);
}

/**
 * 测试事件处理器注销
 */
TEST_F(EventNotifierComprehensiveTest, TestEventHandlerUnregistration) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    // 注册处理器
    notifier.register_handler("temp_event", [&](const std::string& type, const std::string& data) {
        event_count_.fetch_add(1);
    });
    
    EXPECT_EQ(notifier.get_handlers_count("temp_event"), 1);
    
    // 触发事件
    notifier.notify_event("temp_event", "test_data");
    EXPECT_EQ(event_count_.load(), 1);
    
    // 注销处理器
    notifier.unregister_handlers("temp_event");
    EXPECT_EQ(notifier.get_handlers_count("temp_event"), 0);
    
    // 再次触发事件
    notifier.notify_event("temp_event", "test_data");
    
    // 验证事件不再被处理
    EXPECT_EQ(event_count_.load(), 1);
}

/**
 * 测试并发事件通知
 */
TEST_F(EventNotifierComprehensiveTest, TestConcurrentEventNotification) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    const int NUM_THREADS = 4;
    const int EVENTS_PER_THREAD = 1000;
    
    // 注册事件处理器
    notifier.register_handler("concurrent_event", [&](const std::string& type, const std::string& data) {
        event_count_.fetch_add(1);
    });
    
    std::vector<std::thread> threads;
    
    // 启动多个线程并发触发事件
    for (int t = 0; t < NUM_THREADS; ++t) {
        threads.emplace_back([&, t]() {
            for (int i = 0; i < EVENTS_PER_THREAD; ++i) {
                notifier.notify_event("concurrent_event", "data_" + std::to_string(t) + "_" + std::to_string(i));
            }
        });
    }
    
    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }
    
    // 验证所有事件都被处理
    EXPECT_EQ(event_count_.load(), NUM_THREADS * EVENTS_PER_THREAD);
}

/**
 * 测试事件通知器生命周期
 */
TEST_F(EventNotifierComprehensiveTest, TestEventNotifierLifecycle) {
    auto notifier = std::make_unique<SimpleEventNotifier>();
    
    // 初始状态
    EXPECT_FALSE(notifier->is_running());
    EXPECT_EQ(notifier->get_event_types_count(), 0);
    
    // 启动
    notifier->start();
    EXPECT_TRUE(notifier->is_running());
    
    // 注册处理器
    notifier->register_handler("lifecycle_event", [&](const std::string& type, const std::string& data) {
        event_count_.fetch_add(1);
    });
    
    // 触发事件
    notifier->notify_event("lifecycle_event", "test_data");
    EXPECT_EQ(event_count_.load(), 1);
    
    // 停止
    notifier->stop();
    EXPECT_FALSE(notifier->is_running());
    
    // 停止后触发事件应该无效
    notifier->notify_event("lifecycle_event", "test_data");
    EXPECT_EQ(event_count_.load(), 1);
    
    // 销毁
    notifier.reset();
}

/**
 * 测试事件数据传递
 */
TEST_F(EventNotifierComprehensiveTest, TestEventDataTransmission) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    std::vector<std::string> received_data;
    std::mutex data_mutex;
    
    // 注册数据收集处理器
    notifier.register_handler("data_event", [&](const std::string& type, const std::string& data) {
        std::lock_guard<std::mutex> lock(data_mutex);
        received_data.push_back(data);
        event_count_.fetch_add(1);
    });
    
    // 发送不同类型的数据
    std::vector<std::string> test_data = {
        "simple_string",
        "数据包含中文",
        "{\"json\": \"data\", \"value\": 123}",
        "very_long_string_" + std::string(1000, 'x'),
        "",  // 空字符串
        "special_chars_!@#$%^&*()"
    };
    
    for (const auto& data : test_data) {
        notifier.notify_event("data_event", data);
    }
    
    // 验证数据传递
    EXPECT_EQ(event_count_.load(), test_data.size());
    EXPECT_EQ(received_data.size(), test_data.size());
    
    for (size_t i = 0; i < test_data.size(); ++i) {
        EXPECT_EQ(received_data[i], test_data[i]);
    }
}

/**
 * 测试事件通知性能
 */
TEST_F(EventNotifierComprehensiveTest, TestEventNotificationPerformance) {
    SimpleEventNotifier notifier;
    notifier.start();
    
    const int NUM_EVENTS = 10000;
    
    // 注册简单的处理器
    notifier.register_handler("perf_event", [&](const std::string& type, const std::string& data) {
        event_count_.fetch_add(1);
    });
    
    // 测量事件通知性能
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < NUM_EVENTS; ++i) {
        notifier.notify_event("perf_event", "perf_data");
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    
    // 验证性能
    EXPECT_EQ(event_count_.load(), NUM_EVENTS);
    EXPECT_LT(duration.count(), 100000); // 应该在100毫秒内完成
    
    std::cout << "事件通知性能测试: " << NUM_EVENTS << " 个事件耗时 " 
              << duration.count() << " 微秒" << std::endl;
}

/**
 * 测试事件通知器边界条件
 */
TEST_F(EventNotifierComprehensiveTest, TestEventNotifierBoundaryConditions) {
    SimpleEventNotifier notifier;
    
    // 未启动时触发事件
    notifier.register_handler("boundary_event", [&](const std::string& type, const std::string& data) {
        event_count_.fetch_add(1);
    });
    
    notifier.notify_event("boundary_event", "test_data");
    EXPECT_EQ(event_count_.load(), 0); // 未启动，事件不应被处理
    
    // 启动后触发事件
    notifier.start();
    notifier.notify_event("boundary_event", "test_data");
    EXPECT_EQ(event_count_.load(), 1);
    
    // 触发不存在的事件类型
    notifier.notify_event("nonexistent_event", "test_data");
    EXPECT_EQ(event_count_.load(), 1); // 计数不应改变
    
    // 空事件类型和数据
    notifier.register_handler("", [&](const std::string& type, const std::string& data) {
        event_count_.fetch_add(1);
    });
    
    notifier.notify_event("", "");
    EXPECT_EQ(event_count_.load(), 2);
    
    // 停止后再次触发
    notifier.stop();
    notifier.notify_event("boundary_event", "test_data");
    EXPECT_EQ(event_count_.load(), 2); // 计数不应改变
} 